/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package datos;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.*;
import logica.cliente.Cliente;
import logica.cliente.ClienteRMIinterface;
import logica.cliente.Usuario;

/**
 *
 * @author Abel Ricardo
 */
public class guardararchivo {
   private File file; 
   private String Sala="";   

  public String obtenermidireccionip(){
      String ip =null;  
      try {
            NetworkInterface ni = NetworkInterface.getByName("eth0");
             Enumeration<InetAddress> inetAddresses =  ni.getInetAddresses();


             while(inetAddresses.hasMoreElements()) {
                 InetAddress ia = inetAddresses.nextElement();
                 if(!ia.isLinkLocalAddress()) {
                     System.out.println("IP: " + ia.getHostAddress());
                     ip=ia.getHostAddress();
                 }
             }
        } catch (SocketException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ip;
  }
   
   
   //Si soy servidor, guardo el mensaje en un archivo txt  
public void guardarmensaje(Usuario usuario) throws FileNotFoundException, UnsupportedEncodingException, IOException{
//if (usuario.isServidor() || usuario.isServidorrespaldo())
//{
    System.out.println("Entro al metodo guardarmensaje");
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//saber que sistema operativo estas usando
switch(usuario.getSala()){
      case 1:
         Sala="sala1";
         break;
      case 2:
          Sala="sala2";
         break;
          case 3:
          Sala="sala3";
         break;
              case 4:
          Sala="sala4";
         break;
      }
String ruta;

      
        ruta="src/Archivos/Servidor/"+Sala+".txt";  

file = new File(ruta);
if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}
/*la clave de activar o no la sobreescritura esta en FileOutputStream(file, true) si le ponemos en true entonces agregas al final de la linea */

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), "UTF8"));
out.write(usuario.getNombre()+" : "+usuario.getMensaje()+"\n");
out.close();
 System.out.println("se guardo el mensaje");
mostramensajesclientes(usuario);

respaldarmensaje(usuario);
//}
}

public void guardarmensajerespaldo(Usuario usuario)throws FileNotFoundException, UnsupportedEncodingException, IOException{
   System.out.println("Entro al metodo guardarmensajerespaldo");
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//saber que sistema operativo estas usando
switch(usuario.getSala()){
      case 1:
         Sala="sala1";
         break;
      case 2:
          Sala="sala2";
         break;
          case 3:
          Sala="sala3";
         break;
              case 4:
          Sala="sala4";
         break;
      } 
String ruta;
ruta="src/Archivos/Servidor/"+Sala+".txt";  
      
System.out.println(ruta);
file = new File(ruta);


if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), "UTF8"));
out.write(usuario.getMensaje());
out.write("\n");
out.close();
 System.out.println("se guardo el mensaje de respaldo");
//}
}


public void guardariprespaldo(Usuario usuario)throws FileNotFoundException, UnsupportedEncodingException, IOException{
   System.out.println("Entro al metodo guardarmensajerespaldo");
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//saber que sistema operativo estas usando
switch(usuario.getSala()){
      case 1:
         Sala="ipsala1";
         break;
      case 2:
          Sala="ipsala2";
         break;
          case 3:
          Sala="ipsala3";
         break;
              case 4:
          Sala="ipsala4";
         break;
      } 
String ruta;
ruta="src/Archivos/Servidor/"+Sala+".txt";  
      
System.out.println(ruta);
file = new File(ruta);


if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), "UTF8"));
out.write(usuario.getMensaje());
out.write("\n");
out.close();
 System.out.println("se guardo la ip de respaldo");
//}
}


public void eliminararchivomensajes(Usuario usuario){
     System.out.println("Entro al metodo eliminar archivos mensaje");
    switch(usuario.getSala()){
      case 1:
         Sala="sala1";
         break;
      case 2:
          Sala="sala2";
         break;
          case 3:
          Sala="sala3";
         break;
              case 4:
          Sala="sala4";
         break;
      } 
String ruta;
ruta="src/Archivos/Servidor/"+Sala+".txt";  
      
System.out.println(ruta);
file = new File(ruta);
if (file.delete()){ System.out.println("se elimino el archivo mensaje");}
}

public void eliminararchivoip(Usuario usuario){
     System.out.println("Entro al metodo eliminar archivos ip");
     System.out.println(usuario.getSala());
    switch(usuario.getSala()){
      case 1:
         Sala="ipsala1";
         break;
      case 2:
          Sala="ipsala2";
         break;
          case 3:
          Sala="ipsala3";
         break;
              case 4:
          Sala="ipsala4";
         break;
      } 
String ruta;
ruta="src/Archivos/Servidor/"+Sala+".txt";  
      
System.out.println(ruta);
file = new File(ruta);
if (file.delete()){ System.out.println("se elimino el archivo de ip");}
}

public void salirdelasala(Usuario usuario) throws IOException{
    
    ArrayList<Usuario> ip = new ArrayList<Usuario>();
    System.out.println("Salir de sala");
    ip =obteneripclientes(usuario.getSala());
    
    eliminararchivoip(usuario);
    int cont=0;
    while(ip.size()>cont){
            System.out.println(ip.get(cont).getDireccionIP());
            if(!ip.get(cont).getDireccionIP().equals(usuario.getDireccionIP()))
            {
             System.out.println(ip.get(cont).getDireccionIP());
             System.out.println(usuario.getDireccionIP());
            guardaripsala(ip.get(cont));
            }
            cont++; }
    
    System.out.println("termino metodo salir de sala");
}

public void borrarlinea(int n){
    
    
    
    
}
//El mensaje que llega al cliente que trabaja como servidor se envia a los demas clientes de la misma sala
public void mostramensajesclientes(Usuario usuario){
        try {
            String Salaip = null;
                 switch(usuario.getSala()){
                  case 1:
                     Salaip="ipsala1.txt";
                     break;
                  case 2:
                      Salaip="ipsala2.txt";
                     break;
                      case 3:
                      Salaip="ipsala3.txt";
                     break;
                          case 4:
                      Salaip="ipsala4.txt";
                     break;
                  }
                File f = new File( "src/Archivos/Servidor/"+Salaip );
                BufferedReader entrada;
                entrada = new BufferedReader( new FileReader( f ) );
                String linea;
                System.out.println("mostra mensajes :");
                try {
                    //lee las ip de los clientes para reenviar el mensaje
                    while(entrada.ready()){
                    linea = entrada.readLine();
                    System.out.println(linea);
                    
                        
                        ClienteRMIinterface e;
                        
                    try {
                        e = (ClienteRMIinterface) Naming.lookup("rmi://"+linea+":1099/info");
                        e.mostramensajermi(usuario);
                    } catch (NotBoundException ex) {
                        System.out.println("NotBoundException");
                    } catch (MalformedURLException ex) {
                        System.out.println("MalformedURLException");
                    } catch (RemoteException ex) {
                        System.out.println("RemoteException");
                    }
                        
                    }
                } catch (IOException ex) {
                    Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
                }

            
        } catch (FileNotFoundException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }

    
}

//el servidor verifica que la ip del servidor de respaldo no sea igual a la de el
public boolean ipservidorrespaldoigualaprincipal()
{
    System.out.println("comparacion de servidor principal con respaldo");
        
            String direccion = obtenermidireccionip();
        if (direccion.equals(obtenerservidorderespaldo()))
            {
                return true;
            }
            return false;
        
        
}
//El servidor respalda el mensaje en el servidor de respaldo
public void respaldarmensaje(Usuario usuario){
     System.out.println("Entro al metodo respaldar mensaje");
     ArrayList<Usuario> mensajes = new ArrayList<Usuario>();
     mensajes= obtenerconversacion(usuario.getSala());
    try{
        //verifica que la ip del servidor de respaldo no sea igual a la del principal
        if (ipservidorrespaldoigualaprincipal()==false){
            
            
            System.out.println("respaldo y principal son diferentes");
            int cont=0;
             ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+obtenerservidorderespaldo()+":1099/info");
           
             e.eliminarmensaje(usuario);
             while(mensajes.size()>cont){
            System.out.println(mensajes.get(cont).getMensaje());
            e.escribirmensajederespaldo(mensajes.get(cont));
            cont++;
            }
              System.out.println("se respaldo los mensajes");
        
        }
        else{activargrandulon();}
        }catch (Exception e) 
        {
            activargrandulon();
            System.out.println("Exception en respaldar mensaje");
            
           
        }
}

public void respaldarip(Usuario usuario){
     System.out.println("Entro al metodo respaldar ip");
     ArrayList<Usuario> ip = new ArrayList<Usuario>();
     ip= obteneripclientes(usuario.getSala());
    try{
        //verifica que la ip del servidor de respaldo no sea igual a la del principal
        if (ipservidorrespaldoigualaprincipal()==false){
            
            
            System.out.println("respaldo y principal son diferentes");
            int cont=0;
             ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+obtenerservidorderespaldo()+":1099/info");
           
             e.eliminarip(usuario);
             while(ip.size()>cont){
            System.out.println(ip.get(cont).getMensaje());
            e.entraraunasala(ip.get(cont));
            cont++;
            }
              System.out.println("se respaldo las ip");
        
        }
        else{activargrandulon();}
        }catch (Exception e) 
        {
            System.out.println("Exception en respaldar mensaje");
            
           
        }
}
//algoritmo del eleccion
public void grandulon(){
    System.out.println("inicio grandulon");
    String miIp;
    String direccion= "";
        int cont=0;
        File f = new File( "src/Archivos/Cliente/ipclientes.txt" );
        BufferedReader entrada;
        try {
            entrada = new BufferedReader( new FileReader( f ) );
            String linea;
        //lee las ip de los clientes para reenviar el mensaje
        direccion = obtenermidireccionip();
        while(entrada.ready()){
        linea = entrada.readLine();
       
        System.out.println(linea);
        try{
            if (esmayor(direccion,linea)){
                System.out.println(linea+" es mayor que "+direccion);
            ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+linea+":1099/info");
            //le pregunta a los demas si esta activo
            e.estasactivo();
            cont++;}
        }catch (Exception e) 
        {
           System.out.println("Exception en grandulon");
        }}
        } catch (IOException ex) {
            System.out.println("IOException en grandulon");
        }
        
    
         if (cont==0){
        
            
            System.out.println("enviando mi ip como servidor de respaldo en grandulon");
            enviarmiIp();
           
        
         }else{}
        
    
} 
//envio mi ip ya que por el algoritmo quede de servidor de respaldo
public void enviarmiIp()
{
     System.out.println("Entro al metodo enviarmi ip");
   Usuario usuario = new Usuario();
     String miIp;
        
        File f = new File( "src/Archivos/Cliente/ipclientes.txt" );
        BufferedReader entrada;
        try {
            entrada = new BufferedReader( new FileReader( f ) );
            String linea;
        //lee las ip de los clientes para reenviar el mensaje
        String direccion = obtenermidireccionip();
        usuario.setDireccionIP(direccion);
        while(entrada.ready()){
        linea = entrada.readLine();
       
        System.out.println(linea);
        try{
            
            ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+linea+":1099/info");
            //le pregunta a los demas si esta activo
            e.guardaripservidorderespaldo(usuario);
            
        }catch (Exception e) 
        {
            System.out.println("Exception en enviar mi ip");
        }}
         System.out.println("pude enviar mi ip");
        } catch (IOException ex) {
            System.out.println("IOException en enviar mi ip");
        }
}
//el servidor le dice a un cliente que active la eleccion de grandulo para elegir un servidor de respaldo
public void activargrandulon(){
    System.out.println("buscando respaldo, activar grandulon");
        try {
            int cont=0;
                File f = new File( "src/Archivos/Cliente/ipclientes.txt" );
                BufferedReader entrada;
                entrada = new BufferedReader( new FileReader( f ) );
                String linea;
                boolean sigue=true;
                //lee las ip de los clientes para reenviar el mensaje
                String direccion;
                direccion = obtenermidireccionip();
               
                while(entrada.ready() && sigue==true){
                
                linea = entrada.readLine();
                
                System.out.println(linea);
                if (direccion!=linea){
                        try {
                            if (!obtenerservidorderespaldo().equals(linea)){
                            ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+linea+":1099/info");
                            //le pregunta a los demas si esta activo, si esta activo este ciente activa al grandulon
                            e.estasactivo();
                            sigue=false;
                            System.out.println("mando mensaje de si esta activo a :"+ linea);}
                        } catch (NotBoundException ex) {
                            System.out.println("NotBoundException en activar grandulon");
                        } catch (MalformedURLException ex) {
                            System.out.println("MalformedURLException en activar grandulon");
                        } catch (RemoteException ex) {
                            System.out.println("RemoteException en activar grandulon");
                        }
                        
                      
                }
                  
             }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}
//ve si una direccion es mayor que la otra
public boolean esmayor(String dir1,String dir2)
    {
      int numero1=0;
      int numero2=0;
      int contadormayor=0;
      boolean mayor=false;
      //obtengo los numeors de las ip para comparar
      StringTokenizer direcc1 = new StringTokenizer(dir1,"."); 
      StringTokenizer direcc2 = new StringTokenizer(dir2,".");
      while (direcc1.hasMoreTokens()){
            numero1 = Integer.parseInt(direcc1.nextToken());
            numero2 = Integer.parseInt(direcc2.nextToken());
            //comparo si la direccion 2 es mayor que la 1
            if (numero2>numero1)
            {
                //si encuantra que si es mayo suma al contador
                contadormayor++;
            }
            System.out.println (direcc1.nextToken());
      }
      
      if(contadormayor>0)
      {
      mayor=true;
      }
      return mayor;
    }
//guarda las ips activas de las salas
public void guardaripsala(Usuario usuario) throws FileNotFoundException, UnsupportedEncodingException, IOException{
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//saber que sistema operativo estas usando
      System.out.println("Usuario : "+usuario.getDireccionIP()+" "+usuario.getSala());
switch(usuario.getSala()){
      case 1:
         Sala="ipsala1";
         break;
      case 2:
          Sala="ipsala2";
         break;
          case 3:
          Sala="ipsala3";
         break;
              case 4:
          Sala="ipsala4";
         break;
      }
 
String ruta;
  
      
        ruta="src/Archivos/Servidor/"+Sala+".txt";  
      
System.out.println(ruta);
file = new File(ruta);
if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}
/*la clave de activar o no la sobreescritura esta en FileOutputStream(file, true) si le ponemos en true entonces agregas al final de la linea */
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true), "UTF8"));
out.write(usuario.getDireccionIP());
out.write("\n");
out.close();
    
}


//obtengo la ip del servidor de respaldo
public String obtenerservidorderespaldo(){
    try {
            File f = new File( "src/Archivos/Cliente/ipservidorrespaldo.txt" );
            BufferedReader entrada;
            
                entrada = new BufferedReader( new FileReader( f ) );
                String linea;
            //lee las ip de los clientes para reenviar el mensaje
            while(entrada.ready()){
            linea = entrada.readLine();
           
            System.out.println(linea);
            return  linea;
        }
        
        } catch (IOException ex) {
            
            Logger.getLogger(Cliente.class.getName()).log(Level.SEVERE, null, ex);
           
        } 
    return "";
}
//guarda la ip del servidor para que el cliente la use
public void guardaripservidor(String ip) throws IOException{
     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      String  ruta="src/Archivos/Cliente/ipservidorprincipal.txt";  
      System.out.println(ruta);
      file = new File(ruta);
if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}
/*la clave de activar o no la sobreescritura esta en FileOutputStream(file, true) si le ponemos en true entonces agregas al final de la linea */
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, false), "UTF8"));
out.write(ip);
out.write("\n");
out.close();
if (obtenerservidorderespaldo().equals(obtenermidireccionip()))
{
        try {
            ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+obtenerservidorderespaldo()+":1099/info");
                 //le pregunta a los demas si esta activo
                 e.convertirseenservidor();
        } catch (NotBoundException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (MalformedURLException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (RemoteException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
    
    
}

}
//guarda la ip del servidor de respaldo en un txt
public void guardaripservidorderespaldo(String ip) throws IOException{
     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

      String  ruta="src/Archivos/Cliente/ipservidorrespaldo.txt";  
     
System.out.println(ruta);

file = new File(ruta);
if (!file.exists()) {
        try {
            if (file.createNewFile()) {
            System.out.println("El fichero se ha creado correctamente");
            } else {

            System.out.println("No ha podido ser creado el fichero");
            }
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
}
/*la clave de activar o no la sobreescritura esta en FileOutputStream(file, true) si le ponemos en true entonces agregas al final de la linea */
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, false), "UTF8"));
out.write(ip);
out.write("\n");
out.close();
}

public ArrayList<Usuario> obtenerconversacion(int sala){
ArrayList <Usuario> ipclientes= new ArrayList<Usuario>();
    try {
            
            
            
                    String Salaip = null;
                    switch(sala){
                  case 1:
                     Salaip="sala1.txt";
                     break;
                  case 2:
                      Salaip="sala2.txt";
                     break;
                      case 3:
                      Salaip="sala3.txt";
                     break;
                          case 4:
                      Salaip="sala4.txt";
                     break;
                  }
                    
                    File f = new File( "src/Archivos/Servidor/"+Salaip );
                    BufferedReader entrada;
                    entrada = new BufferedReader( new FileReader( f ) );
                    String linea;
                    //lee las ip de los clientes para reenviar el mensaje
                   
                    while(entrada.ready()){
                        Usuario usuario = new Usuario();
                            linea = entrada.readLine();
                            System.out.println(linea);
                            usuario.setSala(sala);
                            usuario.setMensaje(linea);
                            ipclientes.add(usuario);
                            //JLListaUsuarios.
                        
                          
                    }
                   
            
            
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ipclientes;
    
}

public void mostrarmensajeguardados(Usuario usuario){
     System.out.println("Entro al metodo mostrar mensajes guardados");
     ArrayList<Usuario> mensajes = new ArrayList<Usuario>();
     mensajes= obtenerconversacion(usuario.getSala());
    try{
        //verifica que la ip del servidor de respaldo no sea igual a la del principal
            int cont=0;
            System.out.println(usuario.getDireccionIP());
             ClienteRMIinterface e= (ClienteRMIinterface) Naming.lookup("rmi://"+usuario.getDireccionIP()+":1099/info");
           while(mensajes.size()>cont){
               System.out.println("cantidad de linea de los mensajes : "+ cont);
            System.out.println(mensajes.get(cont).getMensaje());
            if (mensajes.size()<30 ){ 
              e.mostrarmensajermi2(mensajes.get(cont));
            
            }else{
                
                if ((mensajes.size()-30)<=cont){e.mostrarmensajermi2(mensajes.get(cont));}
            
            
            }
            cont++;
            }
              System.out.println("se mostro los mensajes");
        
               }catch (Exception e) 
        {
            System.out.println(e);
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, e);
           
        }
}

public ArrayList<Usuario> obteneripclientes(int sala){
    System.out.println("entro al metodo obtener ip clientes");
    ArrayList <Usuario> ipclientes= new ArrayList<Usuario>();    
    try {
           
                       
                    String Salaip = null;
                    switch(sala){
                  case 1:
                     Salaip="ipsala1.txt";
                     break;
                  case 2:
                      Salaip="ipsala2.txt";
                     break;
                      case 3:
                      Salaip="ipsala3.txt";
                     break;
                          case 4:
                      Salaip="ipsala4.txt";
                     break;
                  }
                    
                    File f = new File( "src/Archivos/Servidor/"+Salaip );
                    BufferedReader entrada;
                    entrada = new BufferedReader( new FileReader( f ) );
                    String linea;
                    //lee las ip de los clientes para reenviar el mensaje
                   
                    while(entrada.ready()){
                        Usuario usuario = new Usuario();
                            linea = entrada.readLine();
                            System.out.println(linea);
                            usuario.setSala(sala);
                            usuario.setDireccionIP(linea);
                            ipclientes.add(usuario);
                            //JLListaUsuarios.
                        
                          
                    }
                   
            
            
        } catch (IOException ex) {
            Logger.getLogger(guardararchivo.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ipclientes;
}



}
